# Create your views here.
# -*- coding: utf-8 -*-
from django.views.generic.list_detail import object_list, object_detail
from wal.pedidos.models import Pedido, DetallePedido
from wal.control.models import Control, DetalleControl, Evaluacion, Accion, Stock
from wal.expedicion.models import Expedicion, DetalleExpedicion
from wal.articulos.models import Ensamblado, Partes
from wal.pedidos.forms import PedidosForm, DetallePedidoForm, FechasForm, SearchForm
from django.template.context import RequestContext
from django.shortcuts import render_to_response
#from wal.views import update_object, create_object , delete_object
from django.views.generic.create_update import update_object, create_object , delete_object
from django.core.exceptions import ObjectDoesNotExist
from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect, HttpResponse
from wal.views import split_query_into_keywords, corregirEstado
from django.utils.encoding import smart_str, smart_unicode
from dateutil.relativedelta import relativedelta
import datetime
#from wal.estadisticas.views import asd
def search_for_keywords(keywords):
    """Make a search that contains all of the keywords."""
    pedidos = Pedido.objects.all()
    for keyword in keywords:
        pedidos = pedidos.filter(nombre__icontains=keyword)
    return pedidos

def obtenerPedido(request,object_id):
    if int(object_id):
        try:
            objectoPedido = Pedido.objects.get(id=object_id)
        except ObjectDoesNotExist:
            return 'No existe el objecto'
    else:
        return 'No existe el objecto'
    return objectoPedido

def obtenerDetallePedido(request,object_id):
    if int(object_id):
        try:
            objectoDetalle = DetallePedido.objects.get(id=object_id)
        except ObjectDoesNotExist:
            return 'No existe el objecto'
    else:
        return 'No existe el objecto'
    return objectoDetalle

def finalizar(request,object_id):
    pedido = obtenerPedido(request, object_id)
    if pedido == 'No existe el objecto':
        return render_to_response('error.html',{'error':'No existe el objecto'})
    stock = Stock.objects.filter(pedido=pedido)
    ban = 0
    for s in stock:
        if s.stock > 0:
            ban = 1
            break
    if pedido.finalizado == 'M':
        if ban == 1:
            pedido.finalizado = 'I'
        else:
            pedido.finalizado = 'G'
    elif ban == 1:
        pedido.finalizado = 'H'
    elif pedido.finalizado == 'I':
        pedido.finalizado = 'G'
    else:
        pedido.finalizado = 'F'
    pedido.save()
    return HttpResponseRedirect(reverse(ver, args=[object_id]))

def cancelar(request,object_id):
    pedido = obtenerPedido(request, object_id)
    if pedido == 'No existe el objecto':
        return render_to_response('error.html',{'error':'No existe el objecto'})
    c = Control.objects.filter(pedido=pedido)
    if not c:
        pedido.finalizado = 'C'
    elif pedido.finalizado == 'M':
        pedido.finalizado = 'D'
    else:
        pedido.finalizado = 'E'
    pedido.save()
    return HttpResponseRedirect(reverse(ver, args=[object_id]))
        
def listar(request,ot,o,page):
    
    request.breadcrumbs([('Pedidos',request.path)])
    
    if ot=='asc':
        if int(o) == 1:
            orden = "-nombre"
        elif int(o) == 2:
            orden = "-cliente"
        elif int(o) == 3:
            orden = "-fecha"
        elif int(o) == 4:
            orden = "-plazo"
        else:
            orden = "-fecha"
    elif ot=='desc':
        if int(o) == 1:
            orden = "nombre"
        elif int(o) == 2:
            orden = "cliente"
        elif int(o) == 3:
            orden = "fecha"
        elif int(o) == 4:
            orden = "plazo"
        else:
            orden = "fecha"
    else:
        orden = "-fecha"
    if request.method == 'GET':
        form = SearchForm(request.GET)
        if form.is_valid():
            keywords = form.cleaned_data['keywords']
            keyword_list = split_query_into_keywords(keywords)
            pedidos = search_for_keywords(keyword_list)
            if pedidos:
                # Show the results
                qs = pedidos.order_by(orden,"-ot")
            else:
                qs = Pedido.objects.none()
#            form = SearchForm()
            return object_list(request,
                   queryset = qs,
                   allow_empty = True,
                   template_name = 'pedidos/listar.html',
                   extra_context = {'ot':ot,'o':o,'page':page,'form':form},
                   paginate_by = 20,
                   page = page,
                   )
    else:
        form = SearchForm()
    return object_list(request,
                       queryset = Pedido.objects.order_by(orden,"-ot"),
                       allow_empty = True,
                       template_name = 'pedidos/listar.html',
                       extra_context = {'ot':ot,'o':o,'page':page,'form':form},
                       paginate_by = 20,
                       page = page,
                       )
    
def ver(request, object_id):
    
    pedido = obtenerPedido(request, object_id)
    if pedido == 'No existe el objecto':
        return render_to_response('error.html',{'error':'No existe el objecto'})
    
    request.breadcrumbs([('Pedidos',reverse(listar,args=['asc',3,1])),(pedido.nombre,request.path)])
    
    if request.method == "POST":
        cforms = DetallePedidoForm(request.POST, instance=DetallePedido())
        if cforms.is_valid():
            new_detalle = cforms.save(commit=False)
            art = new_detalle.articulo
            ens = Ensamblado.objects.filter(nombre=art.nombre)
            if ens:
                ens = Ensamblado.objects.get(nombre=art.nombre)
                partes = Partes.objects.filter(ensamblado=ens)
                for p in partes:
                    c = p.cantidad*new_detalle.cantidad
                    new_det = DetallePedido.objects.filter(pedido=pedido,articulo=p.articulo)
                    if new_det:
                        new_det = DetallePedido.objects.get(pedido=pedido,articulo=p.articulo)
                        new_det.cantidad = new_det.cantidad + c
                    else:
                        new_det = DetallePedido(pedido=pedido,articulo=p.articulo,cantidad=c,proceso=pedido.proceso)
                    new_det.save()
                    cargar_Stock(pedido,new_det)
            else:
                new_det = DetallePedido.objects.filter(pedido=pedido,articulo=new_detalle.articulo)
                if new_det:
                    new_det = DetallePedido.objects.get(pedido=pedido,articulo=new_detalle.articulo)
                    new_det.cantidad = new_det.cantidad + new_detalle.cantidad
                    new_det.save()
                    cargar_Stock(pedido,new_det)
                else:
                    new_detalle.pedido = pedido
                    new_detalle.proceso = pedido.proceso
                    new_detalle.save()
                    cargar_Stock(pedido,new_detalle)
            return HttpResponseRedirect(reverse(ver, args=[object_id]))
    else:
        cforms = DetallePedidoForm(instance=DetallePedido())
    detalle = DetallePedido.objects.filter(pedido=object_id)
    list = []
    detcant = 0
    for item in detalle:
        detcant = detcant + item.cantidad
        list.append(item)
    stock = Stock.objects.filter(pedido=object_id)
    proc = 0
    des = 0
    dep = 0
    for st in stock:
        proc = proc + st.procesado
        des = des + st.despachado
        dep = dep + st.stock
    return render_to_response('pedidos/detalles.html', {'pedido': pedido, 'detalle': list, 'detalle_forms': cforms, 'pcant': detcant,'proc': proc,'des': des,'dep': dep}, context_instance=RequestContext(request))

def cargar_Stock(pedido,new_detalle):
    con = Control.objects.filter(pedido=pedido)
    ccantc = 0
    ccant = 0
    if con:
        for c in con:
            det = DetalleControl.objects.filter(control=c,articulo=new_detalle.articulo,proceso=new_detalle.proceso,nuevo='S')
            for d in det:
                ccant = ccant + d.cantidad
                
            detc = DetalleControl.objects.filter(control=c,articulo=new_detalle.articulo,proceso=new_detalle.proceso,conformidad='C')
            for d in detc:
                ccantc = ccantc + d.cantidad
    exp = Expedicion.objects.filter(pedido=pedido)
    ecant = 0
    if exp:
        for e in exp:
            det = DetalleExpedicion.objects.filter(expedicion=e,articulo=new_detalle.articulo,proceso=new_detalle.proceso)
            for d in det:
                ecant = ecant + d.cantidad
    st = ccantc - ecant
    stock = Stock.objects.filter(pedido=pedido,articulo=new_detalle.articulo,proceso=new_detalle.proceso)
    if stock:
        stock = Stock.objects.get(pedido=pedido,articulo=new_detalle.articulo,proceso=new_detalle.proceso)
        stock.cantidad = new_detalle.cantidad
        stock.procesado = ccant
        stock.stock = st
        stock.despachado = ecant
        stock.save()
    else:
        new_stock = Stock(pedido=pedido,articulo=new_detalle.articulo,proceso=new_detalle.proceso,cantidad=new_detalle.cantidad,procesado=ccant,stock=st,despachado=ecant)
        new_stock.save()
                
def crear(request):
    
    request.breadcrumbs([('Pedidos',reverse(listar,args=['asc',3,1])),('Crear Pedido',request.path)])
    
    if request.method == "POST":
        pform = PedidosForm(request.POST, instance=Pedido())
        if pform.is_valid() and pform.clean_fechas():
            #fecha = pform.cleaned_data['fecha']
            #plazo = pform.cleaned_data['plazo']
            #if plazo >= fecha:
            new_pedido = pform.save()
            return HttpResponseRedirect(reverse(ver, args=[new_pedido.id]))
#            else:
#                raise pform.ValidationError("Las Fechas están mal!")
    else:
        pform = PedidosForm(instance=Pedido())
    return render_to_response('pedidos/pedido.html', {'form': pform}, context_instance=RequestContext(request))

def editar(request, object_id):
    pedido = obtenerPedido(request, object_id)
    if pedido == 'No existe el objecto':
        return render_to_response('error.html',{'error':'No existe el objecto'})

    request.breadcrumbs([('Pedidos',reverse(listar,args=['asc',3,1])),('Editar '+pedido.nombre,request.path)])
    
    if request.method == 'POST':
        cforms = PedidosForm(request.POST, instance=Pedido())
        if cforms.is_valid():
            epedido = cforms.save(commit=False)
            cor = corregirEstado(request,pedido,epedido.fecha,epedido.plazo)
            controles = Control.objects.filter(pedido=pedido)
            
#             if pedido.proceso != epedido.proceso:
#                 year = epedido.fecha.year
#                 start = datetime.date(year,1,1)
#                 end = datetime.date(year,12,31)
#                 if Pedido.objects.filter(proceso=epedido.proceso, fecha__range=(start,end)):
#                     last = Pedido.objects.filter(proceso=epedido.proceso,fecha__range=(start,end))
#                     last = len(last)
#                     count = last + 1
#                 else:
#                     count = 1
#                 epedido.ot = count
#                 if epedido.proceso == 'C':
#                     epedido.nombre = str(epedido.cliente) + " (GC" + str(epedido.ot) + "/" + str(epedido.fecha.year) + ")"
#                 else:
#                     epedido.nombre = str(epedido.cliente) + " (GE" + str(epedido.ot) + "/" + str(epedido.fecha.year) + ")"
            
            if controles:
                for c in controles:
                    c.cliente = epedido.cliente
                    c.save()
                    det = DetalleControl.objects.filter(control=c)
                    if det:
                        for d in det:
                            evaluaciones = Evaluacion.objects.filter(detalle=d)
                            if evaluaciones:
                                for ev in evaluaciones:
                                    ev.save()
                expediciones = Expedicion.objects.filter(pedido=pedido)
                if expediciones:
                    for e in expediciones:
                        e.cliente = epedido.cliente
                        e.save()
    
    return update_object(request,
                        model = Pedido, 
                        #form_class = PedidosForm,
                        template_name = 'pedidos/pedido.html', 
                        post_save_redirect = reverse(ver,args=[object_id]),
                        object_id = object_id,
                        form_class = PedidosForm
                        )
    

def borrar(request, object_id,ot,o,page):
    pedido = obtenerPedido(request, object_id)
    if pedido == 'No existe el objecto':
        return render_to_response('error.html',{'error':'No existe el objecto'})
    return delete_object(request,
                         model = Pedido, 
                         template_name = 'pedidos/confirm_delete_pedido.html', 
                         post_delete_redirect = reverse(listar, args=[ot,o,page]),
                         object_id = object_id
                         )
    
def borrarDetalle(request, object_id):
    detalle = obtenerDetallePedido(request, object_id)
    if detalle == 'No existe el objecto':
        return render_to_response('error.html',{'error':'No existe el objecto'})
    pedido = detalle.pedido
    if request.method == "POST":
        stock = Stock.objects.filter(pedido=pedido,articulo=detalle.articulo,proceso=detalle.proceso)
        if stock:
            st = Stock.objects.get(pedido=pedido,articulo=detalle.articulo,proceso=detalle.proceso)
            st.delete()
    return delete_object(request,
                         model = DetallePedido, 
                         template_name = 'pedidos/confirm_delete_detalle.html', 
                         post_delete_redirect = reverse(ver, args=[pedido.id]),
                         object_id = object_id
                         )
#---------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------
#----------------------------------CSV---------------------------------------------
#---------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------

    
import csv

def csvPedido(request,object_id):
    pedido = obtenerPedido(request, object_id)
    if pedido == 'No existe el objecto':
        return render_to_response('error.html',{'error':'No existe el objecto'})
    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=Pedido.csv'
    # Creamos un escritor CSV usando a HttpResponse como "fichero"
    writer = csv.writer(response)
    nombre = smart_str(pedido.cliente) + " (" + smart_str(pedido.ot) + "/" + smart_str(pedido.fecha.year) + ")"
    writer.writerow(['Orden de Trabajo', smart_str(nombre)])
    writer.writerow(['Cliente', smart_str(pedido.cliente)])
    writer.writerow(['Fecha', pedido.fecha])
    writer.writerow(['Plazo', pedido.plazo])
    writer.writerow(['Prioridad', pedido.prioridad])
    writer.writerow(['Responsable', smart_str(pedido.responsable)])
    
    detalles = DetallePedido.objects.filter(pedido=pedido)
    if detalles:
        writer.writerow(['Artículo','Cantidad','Peso(kg)/Superficie(m2)','Proceso','Requisitos','Observación'])

        for detalle in detalles:
            writer.writerow([smart_str(detalle.articulo),detalle.cantidad,detalle.peso,detalle.proceso,smart_str(detalle.requisitos),smart_str(detalle.observacion)])
    return response

def csvPlanillas(request):
    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=Planilla.csv'
    # Creamos un escritor CSV usando a HttpResponse como "fichero"
    writer = csv.writer(response)
    writer.writerow(['PRODUCCION KILOS TRABAJO'])
    writer.writerow(['EXTERNO E INTERNO'])
    inicio = datetime.date(2013,4,1)
    fin = inicio + relativedelta(months = +1)
    controles = Control.objects.filter(fecha__gte = inicio, fecha__lt = fin,pedido__proceso = 'C')
    if controles:
        writer.writerow(['FECHA','UNID ING','KILOS ING','GALV REAL KG'])
        uni = 0
        proc = 0
        real = 0
        detalles = controles.filter(fecha = inicio)
        while inicio != fin:
            if detalles:
                for detalle in detalles:
                    uni = uni + detalle.unidades
                    proc = proc + detalle.kgproc
                    real = real + detalle.kgreal
                writer.writerow([smart_str(inicio),uni,proc,real])
            uni = 0
            proc = 0
            real = 0
            print inicio
            print '\n'
            inicio = inicio + relativedelta(days = +1)
            detalles = controles.filter(fecha = inicio)
            
    return response

def csvStock(request,object_id):
    pedido = obtenerPedido(request, object_id)
    if pedido == 'No existe el objecto':
        return render_to_response('error.html',{'error':'No existe el objecto'})
    response = HttpResponse(mimetype='text/csv')
    response['Content-Disposition'] = 'attachment; filename=Pedido.csv'
    # Creamos un escritor CSV usando a HttpResponse como "fichero"
    
    writer = csv.writer(response)
    nombre = smart_str(pedido.cliente) + " (" + smart_str(pedido.ot) + "/" + smart_str(pedido.fecha.year) + ")"
    writer.writerow(['Orden de Trabajo', smart_str(nombre)])
    writer.writerow(['Cliente', smart_str(pedido.cliente)])
    writer.writerow(['Fecha', pedido.fecha])
    writer.writerow(['Plazo', pedido.plazo])
    writer.writerow(['Prioridad', pedido.prioridad])
    writer.writerow(['Responsable', smart_str(pedido.responsable)])
    
    stock = Stock.objects.filter(pedido=pedido)
    if stock:
        writer.writerow(['Artículo','Proceso','Cantidad','Peso(kg)/Superficie(m2)','Procesado','Stock','Despachado'])

        for st in stock:
            writer.writerow([smart_str(st.articulo),st.proceso,st.cantidad,st.peso,st.procesado,st.stock,st.despachado])
    return response

def csvProduccion(request):
    
    if request.method == "POST":
        pform = FechasForm(request.POST)
        if pform.is_valid() and pform.clean_fechas():
            
            cleaned_data = super(FechasForm, pform).clean()
            inicio = cleaned_data.get('inicio')
            fin = cleaned_data.get('fin')
    
            expediciones = Expedicion.objects.filter(fecha__range=(inicio,fin))
            controles = Control.objects.filter(fecha__range=(inicio,fin))
            
            response = HttpResponse(mimetype='text/csv')
            response['Content-Disposition'] = 'attachment; filename=Pedido.csv'
            # Creamos un escritor CSV usando a HttpResponse como "fichero"
            
            writer = csv.writer(response)
            writer.writerow(['Fecha','Orden de Trabajo','Artículo','Proceso','Cantidad','Peso(kg)/Superficie(m2)','Procesado','Stock','Despachado'])
            
            for c in controles:
                pedido = c.pedido
                nombre = smart_str(pedido.cliente) + " (" + smart_str(pedido.ot) + "/" + smart_str(pedido.fecha.year) + ")"
                det = list(DetalleControl.objects.filter(control=c))
                for d in det:
                    if d.observacion != 'Previamente pasó por un proceso de evaluación por haber estado No Conforme':
                        s = d.cantidad
                        if d.conformidad == 'N':
                            ev = Evaluacion.objects.get(detalle=d)
                            acc = list(Accion.objects.filter(evaluacion=ev))
                            for a in acc:
                                if a.ec == 'N':
                                    s = 0
                                    break
                        
                        can = DetallePedido.objects.filter(pedido=pedido,articulo=d.articulo,proceso=d.proceso)
                        if can:
                            can = DetallePedido.objects.get(pedido=pedido,articulo=d.articulo,proceso=d.proceso)
                            cantidad = can.cantidad
                            
                        stock = Stock.objects.filter(pedido=pedido,articulo=d.articulo,proceso=d.proceso)
                        if stock:
                            stock = Stock.objects.get(pedido=pedido,articulo=d.articulo,proceso=d.proceso)
                            peso = stock.peso
                        else:
                            peso = 0
                        writer.writerow([c.fecha,smart_str(nombre),smart_str(d.articulo),d.proceso,cantidad,peso,d.cantidad,s,0])
            
            for e in expediciones:
                pedido = e.pedido
                nombre = smart_str(pedido.cliente) + " (" + smart_str(pedido.ot) + "/" + smart_str(pedido.fecha.year) + ")"
                det = list(DetalleExpedicion.objects.filter(expedicion=e))
                for d in det:
                    
                    can = DetallePedido.objects.filter(pedido=pedido,articulo=d.articulo,proceso=d.proceso)
                    if can:
                        can = DetallePedido.objects.get(pedido=pedido,articulo=d.articulo,proceso=d.proceso)
                        cantidad = can.cantidad
                        
                    stock = Stock.objects.filter(pedido=pedido,articulo=d.articulo,proceso=d.proceso)
                    if stock:
                        stock = Stock.objects.get(pedido=pedido,articulo=d.articulo,proceso=d.proceso)
                        peso = stock.peso
                    else:
                        peso = 0
                    writer.writerow([e.fecha,smart_str(nombre),smart_str(d.articulo),d.proceso,cantidad,peso,0,0,d.cantidad])
                    
            
            return response
    else:
        pform = FechasForm()
    return render_to_response('pedidos/fechas.html', {'form': pform}, context_instance=RequestContext(request))
    
#---------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------
#---------------------------------------------------------------------------------------    
#---------------------------------------------------------------------------------------------
#--------------REPORTES-----------------------------------------------------------------------------------


from reportlab.lib.pagesizes import A4
from reportlab.lib.styles import  ParagraphStyle as PS
from reportlab.platypus import SimpleDocTemplate, Paragraph
from reportlab.platypus import Table, TableStyle, LongTable
from reportlab.lib import colors
from reportlab.platypus import Spacer
from reportlab.platypus.flowables import PageBreak

def reportPedido(request , object_id):
    
    pedido = obtenerPedido(request, object_id)
    if pedido == 'No existe el objecto':
        return render_to_response('error.html',{'error':'No existe el objecto (Report)'})
    
#    list_control = Control.objects.filter(pedido=pedido)
#    list_expedicion = Expedicion.objects.filter(pedido=pedido)
#    list_det = DetallePedido.objects.filter(pedido=pedido)
#    st = Stock.objects.filter(pedido=pedido)
    
    nombre = smart_str(pedido.cliente) + " (" + smart_str(pedido.ot) + "/" + smart_str(pedido.fecha.year) + ")"
    
    response = HttpResponse(mimetype='application/pdf')
    response['Content-Disposition'] = 'attachment; filename=%s' % nombre
     
    doc = SimpleDocTemplate (response, pagesize=A4, title=nombre, author="Wal Metalúrgica y Construcciones S.R.L.")

    story = []
    
    infoPedidos(request,pedido,story)

    doc.build(story)

    return response   
#----------------------------------------------------------------------------------------------------------------------------
##----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------
#----------------------------------------------------------------------------------------------------------------------------

def reportDePedidos(request):
    
    if request.method == "POST":
        pform = FechasForm(request.POST)
        if pform.is_valid() and pform.clean_fechas():
            
            now = datetime.datetime.now()
            print now
            
            cleaned_data = super(FechasForm, pform).clean()
            inicio = cleaned_data.get('inicio')
            fin = cleaned_data.get('fin')
            
            nombre = "Reporte de pedidos ("+str(inicio)+'|'+str(fin)+')'
            response = HttpResponse(mimetype='application/pdf')
            response['Content-Disposition'] = 'attachment; filename=%s' % nombre
            doc = SimpleDocTemplate (response, pagesize=A4, title=nombre, author="Wal Metalúrgica y Construcciones S.R.L.")
            story = []
            h5 = PS (name = 'Heading 5', fontSize = 12, leading = 16, alignment = 1)
            P = Paragraph("REPORTE DE PEDIDOS", h5)
            story.append(P)
            
            pedidos = []
            
            e = Expedicion.objects.filter(fecha__range=(inicio,fin))
            c = Control.objects.filter(fecha__range=(inicio,fin))
            p = Pedido.objects.filter(fecha__range=(inicio,fin))
#            pedidos = list(Pedido.objects.filter(fecha__range=(inicio,fin)))
            
                
            now = datetime.datetime.now()
            print "inicio de exp",now
            
            for a in e:
                if a.pedido not in pedidos:
                    pedidos.append(a.pedido)
                    infoPedidos(request,a.pedido,story)
                    
            now = datetime.datetime.now()
            print "fin expediciones - inicio controles",now
            
            for a in c:
                if a.pedido not in pedidos:
                    pedidos.append(a.pedido)
                    infoPedidos(request,a.pedido,story)
            
            now = datetime.datetime.now()
            print "fin cont - inicio pedidos",now
            
            for a in p:
                if a not in pedidos:
                    pedidos.append(a)
                    infoPedidos(request,a,story)
            
                    
                    
            now = datetime.datetime.now()
            print "fin de ped - inicio de build",now
            doc.build(story)
            now = datetime.datetime.now()
            print "fin de build",now
            return response
        
    else:
        pform = FechasForm()
    return render_to_response('pedidos/fechas.html', {'form': pform}, context_instance=RequestContext(request))

      
def infoPedidos(request,pedido,story):
    nombre = str(pedido.cliente) + " (" + str(pedido.ot) + "/" + str(pedido.fecha.year) + ")"
                    
    list_control = Control.objects.select_related().filter(pedido=pedido)
    list_expedicion = Expedicion.objects.select_related().filter(pedido=pedido)
    
    st = Stock.objects.select_related().filter(pedido=pedido)
    
    
#    h1 = PS (name = 'Heading 1', fontSize = 12, leading = 16, alignment = 1)
#    h2 = PS (name = 'Heading 2', fontSize = 10, leading = 14, alignment = 0)
#    h3 = PS (name = 'Heading 3', fontSize = 10, leading = 14, alignment = 1)
#    h4 = PS (name = 'Heading 2', fontSize = 10, leading = 14, alignment = 1)
    body_style = PS (name = 'Body', fontSize = 10, leading = 12)
    table_style = TableStyle ([ ('VALIGN', (0,0), (0,-1), 'MIDDLE') ])
    P = Paragraph(pedido.__str__(), body_style)
    story.append(P)
    cuerpoPedido(request,pedido,story)
    if(list_control):
        cuerpoControl(request,pedido,story,list_control)
        if(list_expedicion):
            cuerpoExpedicion(request,pedido,story,list_expedicion)
        if(st):
            cuerpoStock(request,pedido,story,st)

        
def cuerpoPedido(request,pedido,story):
    if pedido.proceso == 'C':
        k = "Peso(kg)"
        x = "Caliente"
    else:
        k = "Superficie(m2)"
        x = "Electrolítico"
    body_style = PS (name = 'Body', fontSize = 10, leading = 12)
    table_style = TableStyle ([ ('VALIGN', (0,0), (0,-1), 'MIDDLE') ])
#---------------PEDIDO----------------------------------------------------------------
    story.append(Paragraph(smart_str("Cliente: "+pedido.cliente.nombre), body_style))
    story.append(Paragraph(smart_str("Fecha: "+str(pedido.fecha)+"        Plazo de entrega: "+str(pedido.plazo)), body_style))
    story.append(Paragraph(smart_str("Responsable: "+pedido.responsable), body_style))
    if pedido.prioridad != None:
        story.append(Paragraph(smart_str("Prioridad: "+pedido.prioridad), body_style))
    story.append(Spacer(0,12))
#----------------DETALLES DEL PEDIDO-------------------------------------------------
    list_det = DetallePedido.objects.select_related().filter(pedido=pedido)
    if (list_det):
        data = []
        data.append([Paragraph(smart_str("Artículo"),body_style), 
                         Paragraph("Cantidad", body_style),
                         Paragraph(k, body_style),
                         Paragraph("Proceso", body_style),
                         Paragraph("Requisitos", body_style),
                         Paragraph(smart_str("Observación"), body_style)])
        for p in list_det:
            data.append([Paragraph(smart_str(p.articulo.nombre),body_style), 
                         Paragraph(str(p.cantidad), body_style),
                         Paragraph(str(p.peso), body_style),
                         Paragraph(x, body_style),
                         Paragraph(smart_str(p.requisitos), body_style),
                         Paragraph(smart_str(p.observacion), body_style)])
    
        t = LongTable(data)
        table_style_1 = table_style
        table_style_1.add('GRID',(0,0),(5,list_det.count()),1,colors.black) 
        t.setStyle(table_style_1)
        story.append(t) 
        story.append(Spacer(0,12))
        
def cuerpoControl(request,pedido,story,list_control):
    if pedido.proceso == 'C':
        k = "Peso(kg)"
        x = "Caliente"
    else:
        k = "Superficie(m2)"
        x = "Electrolítico"
    body_style = PS (name = 'Body', fontSize = 10, leading = 12)
    table_style = TableStyle ([ ('VALIGN', (0,0), (0,-1), 'MIDDLE') ])
##---------------CONTROLES DE CALIDAD DEL PEDIDO--------------------------------------------------
    texto1 = "Controles de Calidad"
    P = Paragraph(texto1, body_style)
    story.append(P)
    
    for control in list_control:
        P = Paragraph(control.__str__(), body_style)
        story.append(P)
        story.append(Paragraph(smart_str("Fecha: "+str(control.fecha)), body_style))
        story.append(Paragraph(smart_str("Responsable: "+control.responsable), body_style))
        story.append(Spacer(0,12))
        #--------------- DETALLES DE LOS CONTROLES DE CALIDAD DEL PEDIDO--------------------------------------------------
        data = []
        data.append([Paragraph(smart_str("Artículo"),body_style), 
                         Paragraph("Proceso", body_style),
                         Paragraph("Cantidad", body_style),
                         Paragraph("Muestras", body_style),
                         Paragraph("Conformidad", body_style),
                         Paragraph(smart_str("Observación"), body_style)])
        list_con_det = DetalleControl.objects.select_related().filter(control=control)
        eval = []
        for p in list_con_det:
            if Evaluacion.objects.filter(detalle=p):
                eval.append(Evaluacion.objects.select_related().get(detalle=p))
            data.append([Paragraph(smart_str(p.articulo.nombre),body_style), 
                         Paragraph(x, body_style),
                         Paragraph(str(p.cantidad), body_style),
                         Paragraph(str(p.muestras), body_style),
                         Paragraph(p.conformidad, body_style),
                         Paragraph(smart_str(p.observacion), body_style)])
    
        t = LongTable(data)
        table_style_1 = table_style
        table_style_1.add('GRID',(0,0),(5,list_con_det.count()),1,colors.black) 
        t.setStyle(table_style_1)
        story.append(t) 
        story.append(Spacer(0,12))
        #--------------------EVALUACIONES DE LOS DETALLES-------------------------------
        if eval:
            texto1 = "Evaluaciones"
            P = Paragraph(texto1, body_style)
            story.append(P)
            
            for ev in eval:
                P = Paragraph(ev.__str__(), body_style)
                story.append(P)
                story.append(Paragraph(smart_str("Fecha: "+str(ev.fecha)), body_style))
                story.append(Paragraph(smart_str("Motivo: "+ev.motivo), body_style))
                story.append(Spacer(0,12))
                #--------------- DETALLES DE LOS CONTROLES DE CALIDAD DEL PEDIDO--------------------------------------------------
                P = Paragraph("Acciones:", body_style)
                story.append(P)
                data = []
                data.append([Paragraph(smart_str("Acción"),body_style), 
                                 Paragraph("Plazo", body_style),
                                 Paragraph("Responsable", body_style),
                                 Paragraph("Conformidad", body_style),
                                 Paragraph("Reprogramado", body_style)])
                list_ev_det = Accion.objects.select_related().filter(evaluacion=ev)
                for p in list_ev_det:
                    data.append([Paragraph(smart_str(p.accion),body_style), 
                                 Paragraph(smart_str(p.plazo), body_style),
                                 Paragraph(smart_str(p.responsable), body_style),
                                 Paragraph(p.conformidad, body_style),
                                 Paragraph(p.reprogramado, body_style)])
            
                t = LongTable(data)
                table_style_1 = table_style
                table_style_1.add('GRID',(0,0),(4,list_ev_det.count()),1,colors.black) 
                t.setStyle(table_style_1)
                story.append(t) 
                story.append(Spacer(0,12))

def cuerpoExpedicion(request,pedido,story,list_expedicion):
    if pedido.proceso == 'C':
        k = "Peso(kg)"
        x = "Caliente"
    else:
        k = "Superficie(m2)"
        x = "Electrolítico"
    body_style = PS (name = 'Body', fontSize = 10, leading = 12)
    table_style = TableStyle ([ ('VALIGN', (0,0), (0,-1), 'MIDDLE') ])
##----------------EXPEDICION------------------------------------------------
    texto1 = "Expediciones"
    P = Paragraph(texto1, body_style)
    story.append(P)
    
    for exp in list_expedicion:
        P = Paragraph(exp.__str__(), body_style)
        tt = smart_unicode("Remisión: ")+exp.remision+"        Responsable: "+exp.responsable
        story.append(P)
        story.append(Paragraph(smart_str("Fecha: "+str(exp.fecha)+"        Factura: "+exp.factura), body_style))
        story.append(Paragraph(smart_str(tt), body_style))
        story.append(Spacer(0,12))
        #--------------- DETALLES DE LOS CONTROLES DE CALIDAD DEL PEDIDO--------------------------------------------------
        data = []
        data.append([Paragraph(smart_str("Artículo"),body_style), 
                         Paragraph("Proceso", body_style),
                         Paragraph("Cantidad", body_style),
                         Paragraph(k, body_style),
                         Paragraph("Receptor", body_style)])
        list_exp_det = DetalleExpedicion.objects.select_related().filter(expedicion=exp)
        for p in list_exp_det:
            data.append([Paragraph(smart_str(p.articulo.nombre),body_style), 
                         Paragraph(x, body_style),
                         Paragraph(smart_str(p.cantidad), body_style),
                         Paragraph(smart_str(p.peso), body_style),
                         Paragraph(smart_str(p.receptor), body_style)])
    
        t = LongTable(data)
        table_style_1 = table_style
        table_style_1.add('GRID',(0,0),(5,list_exp_det.count()),1,colors.black) 
        t.setStyle(table_style_1)
        story.append(t) 
        story.append(Spacer(0,12))
        
def cuerpoStock(request,pedido,story,st):
    if pedido.proceso == 'C':
        k = "Peso(kg)"
        x = "Caliente"
    else:
        k = "Superficie(m2)"
        x = "Electrolítico"
        
    body_style = PS (name = 'Body', fontSize = 10, leading = 12)
    table_style = TableStyle ([ ('VALIGN', (0,0), (0,-1), 'MIDDLE') ])
##----------------DETALLES GENERALES------------------------------------------------
    texto1 = "Detalles Generales"
    P = Paragraph(texto1, body_style)
    story.append(P)
    
#--------------- DETALLES DE LOS CONTROLES DE CALIDAD DEL PEDIDO--------------------------------------------------
    data = []
    data.append([Paragraph(smart_str("Artículo"),body_style), 
                     Paragraph("Proceso", body_style),
                     Paragraph("Cantidad", body_style),
                     Paragraph(k, body_style),
                     Paragraph("Procesado", body_style),
                     Paragraph("Stock", body_style),
                     Paragraph("Despachado", body_style)])
    for p in st:
        data.append([Paragraph(smart_str(p.articulo.nombre),body_style), 
                     Paragraph(x, body_style),
                     Paragraph(smart_str(p.cantidad), body_style),
                     Paragraph(smart_str(p.peso), body_style),
                     Paragraph(smart_str(p.procesado), body_style),
                     Paragraph(smart_str(p.stock), body_style),
                     Paragraph(smart_str(p.despachado), body_style)])

    t = LongTable(data)
    table_style_1 = table_style
    table_style_1.add('GRID',(0,0),(6,st.count()),1,colors.black) 
    t.setStyle(table_style_1)
    story.append(t) 
    story.append(Spacer(0,12))
    story.append(PageBreak())